package co.com.inventarios.logica;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;

import co.com.inventarios.modelo.Bodega;
import co.com.inventarios.modelo.Dlluser;
import co.com.inventarios.modelo.Label;
import co.com.inventarios.modelo.Mngdoc;
import co.com.inventarios.modelo.Mngtdc;
import co.com.inventarios.modelo.MngtdcId;
import co.com.inventarios.modelo.Producto;
import co.com.inventarios.modelo.RequiDoc;
import co.com.inventarios.modelo.RequiDocId;
import co.com.inventarios.modelo.RequiDocWork;
import co.com.inventarios.modelo.RequiPro;
import co.com.inventarios.modelo.RequiProId;
import co.com.inventarios.modelo.RequiProWork;
import co.com.inventarios.modelo.Tipoiva;
import co.com.inventarios.persistencia.BodegaDAO;
import co.com.inventarios.persistencia.EntityManagerHelper;
import co.com.inventarios.persistencia.IMngdocDAO;
import co.com.inventarios.persistencia.IRequiDocDAO;
import co.com.inventarios.persistencia.IRequiProDAO;
import co.com.inventarios.persistencia.LabelDAO;
import co.com.inventarios.persistencia.MngdocDAO;
import co.com.inventarios.persistencia.MngtdcDAO;
import co.com.inventarios.persistencia.ProductoDAO;
import co.com.inventarios.persistencia.QueryBodegaDAO;
import co.com.inventarios.persistencia.QueryMngtdcDAO;
import co.com.inventarios.persistencia.QueryProBodegaDAO;
import co.com.inventarios.persistencia.QueryProductoDAO;
import co.com.inventarios.persistencia.QueryRequiProDao;
import co.com.inventarios.persistencia.QueryRequisicionDAO;
import co.com.inventarios.persistencia.QueryTipoivaDAO;
import co.com.inventarios.persistencia.RequiDocDAO;
import co.com.inventarios.persistencia.DlluserDAO;
import co.com.inventarios.persistencia.RequiProDAO;
import co.com.inventarios.persistencia.TipoivaDAO;
import co.com.inventarios.reporte.reportes;

public class RequisicionLogica implements IRequisicionLogica {

	MngtdcId MngtdcId_DAO = new MngtdcId();
	Mngtdc Registroini = new Mngtdc();
	RequiDoc miRequidoc = new RequiDoc();
	RequiPro miRequipro = new RequiPro();
	RequiDocId miId = new RequiDocId();
	IRequiDocDAO lDAO = new RequiDocDAO();
	QueryProBodegaDAO ProBodDAO = new QueryProBodegaDAO();
	IRequiProDAO proDAO = new RequiProDAO();
	MngtdcDAO tdcDAO = new MngtdcDAO();
	double incremento;

	public double getIncremento() {
		return incremento;
	}

	public void setIncremento(double incremento) {
		this.incremento = incremento;
	}

	public List<Bodega> consultarBodegaLike(String propiedad, String valor,
			String autorizadas) throws Exception {
		return new QueryBodegaDAO().findByPropertyLike(propiedad, valor,
				autorizadas);
	}

	public Bodega consultarBodega(String codigo, String autorizadas)
			throws Exception {
		return new QueryBodegaDAO().findByBodegaId(codigo, autorizadas);
	}

	public Bodega consultarBodegaActiva(String codigo, String valor)
			throws Exception {
		return new QueryBodegaDAO().findByPropertyActivo(codigo, valor);
	}

	// public Bodega consultarBodega(String codigo) throws Exception {
	// return new BodegaDAO().findById(codigo);
	// }

	public List<RequiDoc> buscarTodosRequiDocAll() throws Exception {
		return new QueryRequisicionDAO().findAllR();
	}

	public List<RequiDoc> buscarTodosRequiDocAll_Estado(Long Estado)
			throws Exception {
		return new QueryRequisicionDAO().findAllR_Estado(Estado);
	}

	public List<RequiDoc> buscarTodosRequiDoc(String bodegas) throws Exception {
		return new QueryRequisicionDAO().findAll(bodegas);
	}

	public List<RequiDoc> buscarTodosRequiDoc_Estado(String bodegas, Long Estado)
			throws Exception {
		return new QueryRequisicionDAO().findAll_Estado(bodegas, Estado);
	}

	public List<RequiPro> buscarRequiPro(String empresa, String clase,
			String tipo, String numero) throws Exception {
		Double obj = Double.valueOf(numero);
		return new QueryRequiProDao()
				.Buscar_RequiPro(empresa, clase, tipo, obj);
	}

	public RequiDoc consultarRequiDoc(String propiedad, RequiDocId valor)
			throws Exception {
		return new QueryRequisicionDAO().findByProperty(propiedad, valor);
	}

	public List<RequiDoc> consultarRequiDocProperty(String bodegas,
			String clase, String tipo, String propiedad, String valor)
			throws Exception {
		return new QueryRequisicionDAO().findByProperty_list(bodegas, clase,
				tipo, propiedad, valor);
	}

	public List<RequiDoc> consultarRequiDocProperty_Date(String bodegas,
			String clase, String tipo, String propiedad, Date valor)
			throws Exception {
		return new QueryRequisicionDAO().findByProperty_list_Date(bodegas, clase,
				tipo, propiedad, valor);
	}
	
	public List<RequiDoc> consultarRequiDocPropertyCerradas(String clase,
			String tipo, String propiedad, String valor) throws Exception {
		return new QueryRequisicionDAO().findByProperty_listCerradas(clase,
				tipo, propiedad, valor);
	}

	public List<RequiDoc> consultarRequiDocPropertyCerradas_Bodega(
			String clase, String bodega, String propiedad, String valor)
			throws Exception {
		return new QueryRequisicionDAO().findByProperty_listCerradas_Bod(clase,
				bodega, propiedad, valor);
	}

	public List<RequiDoc> consultarRequiDocPropertyCerradas_Bodega_Date(
			String clase, String bodega, String propiedad, Date valor)
			throws Exception {
		return new QueryRequisicionDAO().findByProperty_listCerradas_Bod_Date(clase,
				bodega, propiedad, valor);
	}
	
	public List<RequiDoc> consultarRequiDocPropertyBodega(String clase,
			String tipo, String propiedad, String valor, String propiedadb,
			String valorb) throws Exception {
		return new QueryRequisicionDAO().findByProperty_listBodega(clase, tipo,
				propiedad, valor, propiedadb, valorb);
	}

	public List<RequiDoc> consultarPropiedadLike(String propiedad, String valor)
			throws Exception {
		// TODO Auto-generated method stub
		return null;
	}

	public void eliminarRequisicion(RequiDocId Req) throws Exception {
		miRequidoc = new RequiDoc();
		miRequidoc.setId(Req);
		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			lDAO.delete(miRequidoc);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}

	}

	public void grabarRequiDoc(RequiDoc Registro) throws Exception {
		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			lDAO.update(Registro);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}

	}

	public String grabarRequiDoc_new(RequiDoc Registro) throws Exception {

		MngtdcId_DAO = new MngtdcId();
		Registroini = new Mngtdc();

		Double consecutiv = MngDocnum_Id(Registro.getId().getReqclase(),
				Registro.getId().getReqtipo());
		int fin = consecutiv.toString().indexOf(".");
		String numero = consecutiv.toString().substring(0, fin);

		MngtdcId_DAO.setTdcclase(Registro.getId().getReqclase());
		MngtdcId_DAO.setTdctipo(Registro.getId().getReqtipo());
		Registroini = new MngtdcDAO().findById(MngtdcId_DAO);
		Registroini.setTdcnumero(consecutiv);
		Registro.getId().setReqnumero(consecutiv);
		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			lDAO.update(Registro);
			new MngtdcDAO().update(Registroini);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}
		return numero;
	}

	public Dlluser consultarRequiUser(String usuario) throws Exception {
		return new DlluserDAO().findById(usuario);
	}

	public Producto consultarRequiProducto(String codigo) throws Exception {
		return new ProductoDAO().findById(codigo);
	}

	public Label consultarlabel(Long codigo) throws Exception {
		return new LabelDAO().findById(codigo);
	}

	public void grabarRequiPro(RequiPro Registro_Pro) throws Exception {

		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			proDAO.update(Registro_Pro);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}

	}

	public Double buscarRequiProId(String empresa, String clase, String tipo,
			Double numero) throws Exception {
		return new QueryRequiProDao().MaxId(empresa, clase, tipo, numero);
	}

	public List<Bodega> buscarBodegas_Aut(String buscar) throws Exception {
		return new QueryBodegaDAO().Buscar_Bodegas_Aut(buscar);
	}

	public RequiDocWork[] findRequisicionSelectedRow(List<RequiDoc> lista)
			throws Exception {
		// TODO Auto-generated method stub
		RequiDocWork requi;

		int max = lista.size();
		RequiDocWork[] arrayRequi = new RequiDocWork[max];

		// List<RequiDoc> lista = buscarTodosRequiDoc();
		if (lista != null) {
			for (int i = 0; i < max; i++) {
				requi = new RequiDocWork();
				requi.setRequidoc(lista.get(i));
				arrayRequi[i] = requi;
			}
		}
		return arrayRequi;
	}

	public RequiProWork[] findRequisicionRowPro(List<RequiPro> lista,
			String bodega) throws Exception {

		RequiProWork requi;

		int max = lista.size();
		// System.err.println("Tipo int maxxxxxxxxxxxxxxxxxxxxxxxxxr" + max +"
		// uuu");
		RequiProWork[] arrayRequi = new RequiProWork[max];

		if (lista != null) {
			for (int i = 0; i < max; i++) {
				requi = new RequiProWork();
				requi.setRequipro(lista.get(i));
				requi.getRequipro().setRequiDoc(lista.get(i).getRequiDoc());
				requi.setCantidadreq(requi.getRequipro().getRqpcantReq()
						.doubleValue()
						- requi.getRequipro().getRqpcantEnt().doubleValue());
				Double exis = (Double) ProBodDAO.procedimiento(requi
						.getRequipro().getProducto().getProcodigo().toString(),
						".", "001", "CC1 ", bodega);

				requi.setExistencia(exis.doubleValue());
				arrayRequi[i] = requi;
			}
		}

		return arrayRequi;
	}

	public RequiProWork[] findRequisicionSelectedRowPro(List<RequiPro> lista,
			String bodega) throws Exception {

		RequiProWork requi;

		int max = lista.size();

		RequiProWork[] arrayRequi = new RequiProWork[max];

		if (lista != null) {
			for (int i = 0; i < max; i++) {
				requi = new RequiProWork();
				requi.setRequipro(lista.get(i));
				requi.getRequipro().setRequiDoc(lista.get(i).getRequiDoc());
				requi.getRequipro().getRequiDoc().setBodega(
						lista.get(i).getRequiDoc().getBodega());
				requi.setCantidadreq(requi.getRequipro().getRqpcantReq()
						.doubleValue()
						- requi.getRequipro().getRqpcantEnt().doubleValue());
//				Double exis = Double.valueOf("50");
				Double exis = (Double) ProBodDAO.procedimiento(requi
						.getRequipro().getProducto().getProcodigo().toString(),
						".", "001", "CC1 ", bodega);

				requi.setExistencia(exis.doubleValue());
				arrayRequi[i] = requi;
			}
		}

		return arrayRequi;
	}

	public List<Mngtdc> buscarDocument_Aut(String buscar, String clase)
			throws Exception {
		return new QueryMngtdcDAO().Buscar_Document_Aut(buscar, clase);

	}

	public Double MngDocnum_Id(String clase, String tipo) throws Exception {
		return new QueryMngtdcDAO().MngDocnum_Id(clase, tipo);
	}

	public List<Producto> buscarTodosProductos() throws Exception {
		return new ProductoDAO().findAll();
	}

	public void grabaconsecutivo(MngtdcId Registro, String numero)
			throws Exception {
		Mngtdc Registroini = new MngtdcDAO().findById(Registro);
		// incremento =
		// MngDocnum_Id(Registro.getTdcclase().toString(),Registro.getTdctipo().toString());
		Registroini.setTdcnumero(Double.valueOf(numero));
		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			new MngtdcDAO().update(Registroini);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			System.err.println(" Error, De Consecutivo");
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}

	}

	public List<Producto> consultarProductosLike(String propiedad, String valor)
			throws Exception {
		return new QueryProductoDAO().findByPropertyLike(propiedad, valor);
	}

	public List<RequiPro> buscarTodosRequiPro() throws Exception {
		return new RequiProDAO().findAll();
	}

	public void eliminarProRequisicion(RequiProId ReqPro) throws Exception {

		miRequipro = new RequiPro();
		miRequipro.setId(ReqPro);

		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			proDAO.delete(miRequipro);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}

	}

	public void actualiza_reqpro(RequiPro requiproact) throws Exception {
		try {
			EntityManagerHelper.getEntityManager().getTransaction().begin();
			new RequiProDAO().update(requiproact);
			EntityManagerHelper.getEntityManager().getTransaction().commit();
		} catch (Exception ex) {
			ex.printStackTrace();
			EntityManagerHelper.getEntityManager().getTransaction().rollback();
		}
	}

	public List<RequiDoc> consultarRequiDocPropertydate(String clase,
			String tipo, String propiedad, Date valor) throws Exception {
		return new QueryRequisicionDAO().findByProperty_listdate(clase, tipo,
				propiedad, valor);
	}

	public List<RequiPro> buscarRequiProTra(String empresa, String clase,
			String tipo, String bodega1, String bodega2) {
		return new QueryRequiProDao().Buscar_RequiProTra(empresa, clase, tipo,
				bodega1, bodega2);
	}

	private QueryRequiProDao QueryRequiProDao() {
		// TODO Auto-generated method stub
		return null;
	}

	public void Imprimir(String Reporte) throws Exception {

		try {
			reportes imprimir_R = new reportes();
			imprimir_R.conexion(Reporte);
			imprimir_R.cargar();
			imprimir_R.visualizar();
		} catch (Exception e) {
			// TODO: handle exception
		}

	}

}
